#include "head.h"

// 双向链表的创建
f_list *init_double_link_list()
{
    // 1、创建动态空间
    f_list *list = (f_list *)malloc(sizeof(f_list));
    if (NULL == list)
    {
        ERRLOG("创建动态空间失败");
        return NULL;
    }
    list->next = NULL;
    return list;
}

// 双向循环链表的插入
void insert_double_node(f_list *list, f_data data, int pos)
{
    if (NULL == list)
{
    ERRLOG("双向循环链表为空");
    return;
}
f_node *new_node = (f_node *)malloc(sizeof(f_node));
if (NULL == new_node)
{
    ERRLOG("创建动态空间失败");
    return;
}
new_node->data = data;
new_node->next = new_node;
new_node->prev = new_node;

// 尾插法实现
if (NULL == list->next) {
    // 空链表，新节点作为第一个节点
    list->next = new_node;
} else {
    // 找到尾节点（头节点的前驱）
    f_node *tail = list->next->prev;
    
    // 插入新节点到尾部
    tail->next = new_node;
    new_node->prev = tail;
    new_node->next = list->next;  // 新节点的后继指向头节点
    list->next->prev = new_node;  // 头节点的前驱指向新节点
}
F_print_M(list, FLIGHTS_FILE);
return;
}

// 双向链表的删除
void delete_double_node(f_list *list, int pos)
{
    if (NULL == list)
    {
        ERRLOG("双向循环链表为空");
        return;
    }
    if (NULL == list->next)
    {
        ERRLOG("链表内无数据");
        return;
    }
    f_node *ptr_1 = list->next;
    f_node *ptr_2 = ptr_1->next;
    if (pos == ptr_1->data.id || list->next == ptr_2)
    {
        // 只有一个元素
        if (list->next == ptr_2)
        {
            free(ptr_1);
            list->next = NULL;
            return;
        }
        // 删除多个元素的第一个元素
        else
        {
            list->next = ptr_2;
            ptr_2->prev = ptr_1->prev;
            ptr_1->prev->next = ptr_2;
            free(ptr_1);
            return;
        }
    }
    // 任意位置删除
    do
    {
        if (pos == ptr_1->data.id)
            break;
        ptr_1 = ptr_1->next;
    } while (ptr_1 != list->next);
    ptr_2 = ptr_1->prev;
    ptr_2->next = ptr_1->next;
    ptr_1->next->prev = ptr_2;
    // F_print((*list)->ADMIN_USER, ADMIN_FILE);
    free(ptr_1);
}

// 双向链表的查找(按照终点站查找)
f_list *find_double_node_name(f_list *list, char *name)
{
    if (NULL == list)
    {
        ERRLOG("链表的动态空间为空");
        return NULL;
    }
    if (NULL == list->next)
    {
        ERRLOG("传入的表内为空");
        return NULL;
    }
    f_list *ptr_1 = init_double_link_list();
    f_node *ptr = list->next;
    do
    {
        if (!strcmp(ptr->data.arrivecity, name))
        {
            printf("去往%s的航班有\n", name);
            insert_double_node(ptr_1, ptr->data, 1);
        }
        ptr = ptr->next;
    } while (ptr != list->next);
if(ptr_1==NULL)
{
    printf("没有找到\n");
}
    return ptr_1;
}

//双向链表查找(按照班次查找)
f_node *find_double_node_pos(f_list *list, int pos)
{
    if (NULL == list)
    {
        ERRLOG("链表的动态空间为空");
        return NULL;
    }
    if (NULL == list->next)
    {
        ERRLOG("传入的表内为空");
        return NULL;
    }
    f_node *ptr = list->next;
    do
    {
        if (ptr->data.id == pos)
        {
            return ptr;
        }
        ptr = ptr->next;
    } while (ptr != list->next);
    return NULL;
}

// 双向链表的遍历
void print_forward_double_link_list(f_list *list)
{
    if (NULL == list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return;
    }
    if (NULL == list->next)
    {
        ERRLOG("双向循环链表 无 数据");
        return;
    }
    sort_flight_list(list);
    // F_scanf_M(list, FLIGHTS_FILE);
    
    f_node *ptr = list->next;
    const char *blue_bg = "\033[34m";     // 蓝色背景
    const char *reset = "\033[0m";        // 重置所有样式
    printf("┌────────┬────────────────┬──────────┬───────────┬────────────┬────────────┬──────────────┬────────┬──────────┬────────────┬──────────┐\n");  
      
    // 表头  
    printf("|  %s班次%s  |      %s机型%s      |  %s起点站%s  |   %s终点站%s  |  %s起飞时间%s  |  %s到达时间%s  |   %s飞行时间%s   |  %s票价%s  |  %s载客量%s  |  %s剩余座位%s  |  %s是否飞%s  |\n"\
        ,blue_bg ,reset,blue_bg,reset,blue_bg,reset,blue_bg ,reset,\
          blue_bg ,reset,blue_bg ,reset,blue_bg ,reset,blue_bg ,reset,\
          blue_bg ,reset,blue_bg ,reset,blue_bg ,reset);  
      
    printf("└────────┴────────────────┴──────────┴───────────┴────────────┴────────────┴──────────────┴────────┴──────────┴────────────┴──────────┘\n");  
  // 下边框（可选，如果需要的话）

    do
    {
        printf("     %d", ptr->data.id);                                              // 航班班次
        printf("      %-18s", ptr->data.flighttype);                                     // 飞机机型
        printf("%s", ptr->data.startcity);                                      // 航班起点站
        printf("        %s", ptr->data.arrivecity);                                     // 航班终点站
        printf("        %02d:%02d\t", ptr->data.starttime[0], ptr->data.starttime[1]); // 起飞时间
        printf("   %02d:%02d", ptr->data.arrivetime[0], ptr->data.arrivetime[1]); // 到达时间
        printf("         %-13s", ptr->data.flytime);                                      // 飞行时间
        printf("%-10d", ptr->data.value);                                         // 票价
        printf("%-10d", ptr->data.maxNUM);                                          // 额定载客量
        printf("%-10d", ptr->data.leftbuyersa);                                    // 剩余座位数量
        printf("\t%c\n", ptr->data.whetherfly);
        printf("\n");
        ptr = ptr->next;
    } while (list->next != ptr);
}
// 排序函数：按班次升序排列双向循环链表
void sort_flight_list(f_list *list) {
    if (NULL == list || NULL == list->next || list->next == list->next->next) {
        return; // 空链表或只有一个节点无需排序
    }

    int swapped;
    f_node *ptr;
    f_node *last = NULL;

    do {
        swapped = 0;
        ptr = list->next; // 指向第一个数据节点

        while (ptr->next != list->next) {
            if (ptr->data.id > ptr->next->data.id) {
                // 交换节点数据
                f_data temp = ptr->data;
                ptr->data = ptr->next->data;
                ptr->next->data = temp;
                swapped = 1;
            }
            ptr = ptr->next;
        }
        last = ptr;
    } while (swapped);
    F_print_M(list, FLIGHTS_FILE);
}
// 双向链表的判空
int is_empty_double_link_list(f_list *list);

// 双向链表的清空
void clear_double_link_list(f_list *list);

// 双向链表的销毁
void free_double_link_list(f_list **list)
{
    if (NULL == (*list))
    {
        ERRLOG("双向循环链表 为 NULL\n");
        return;
    }
    if (NULL == (*list)->next)
    {
        free(*list);
        *list = NULL;
        ERRLOG("双向循环链表 为 NULL\n");
        return;
    }

    f_node *ptr_1 = (*list)->next->prev;
    f_node *ptr_2 = (*list)->next->prev->prev;

    // 释放结点
    for (size_t i = 0; (*list)->next != ptr_1; i++)
    {
        free(ptr_1);
        ptr_1 = ptr_2;
        if ((*list)->next != ptr_2)
        {
            ptr_2 = ptr_2->prev;
        }
    }
    free(ptr_1);

    // 释放头结点
    free(*list);
    *list = NULL;
}

// 按照班次排序
void sort_double_lin_list()
{
FILE *fp = fopen(FLIGHTS_FILE, "r+");
  if (fp == NULL)
  {
    ERRLOG("文件创建失败");
    return;
  }
  fseek(fp, 0, SEEK_SET);
  char ch = '0';
  int line = 0;
  // 判断有多少行
  while (EOF != (ch = fgetc(fp)))
  {
    if (ch == '\n')
    {
      line++;
    }
  }
  // 让光标回到开始
  fseek(fp, 0, SEEK_SET);
  // 数据结构体，用来从文件中读取,读取一次覆盖一次
  f_data data[line];
  f_data temp;
  for (int i = 0; i < line; i++)
  {        
    fscanf(fp, "班次：%d\t机型：%s\t起点站：%s\t终点站：%s\t起飞时间：%d:%d\t到达时间：%d:%d\t飞行时间：%s\t票价：%d\t额定载客量：%d\t剩余座位：%d\t是否起飞：%c\n", &data[i].id, data[i].flighttype, data[i].startcity, data[i].arrivecity, &data[i].starttime[0], &data[i].starttime[1], &data[i].arrivetime[0], &data[i].arrivetime[1], data[i].flytime, &data[i].value, &data[i].maxNUM, &data[i].leftbuyersa, &data[i].whetherfly);
  }
  fclose(fp);
// f_node *ptr = list->next;
  for (int i = 0; i < line; i++)
  {
    for (int j = 0; j < line - i - 1; j++)
    {
      if (data[j].id > data[j + 1].id)
      {
        temp = data[j];
        data[j] = data[j + 1];
        data[j + 1] = temp;
      }
    }
  }
  fp = fopen(FLIGHTS_FILE, "w+");
  if (fp == NULL)
  {
    ERRLOG("文件创建失败");
    return;
  }
  // 让光标回到开始
  fseek(fp, 0, SEEK_SET);
  for (int i = 0; i < line; i++)
  {
    fprintf(fp, "班次：%d\t机型：%s\t起点站：%s\t终点站：%s\t起飞时间：%d:%d\t到达时间：%d:%d\t飞行时间：%s\t票价：%d\t额定载客量：%d\t剩余座位：%d\t是否起飞：%c\n", data[i].id, data[i].flighttype, data[i].startcity, data[i].arrivecity, data[i].starttime[0], data[i].starttime[1], data[i].arrivetime[0], data[i].arrivetime[1], data[i].flytime, data[i].value, data[i].maxNUM, data[i].leftbuyersa, data[i].whetherfly);
  }
  fclose(fp);
}

//购买后座位的变化
f_node *revise_double_node_pos(f_list *list, int pos,f_data data)
{
    if (NULL == list)
    {
        ERRLOG("链表的动态空间为空");
        return NULL;
    }
    if (NULL == list->next)
    {
        ERRLOG("传入的表内为空");
        return NULL;
    }
    f_node *ptr = list->next;
    do
    {
        if (ptr->data.id == pos)
        {
            ptr->data=data;
            return ptr;
        }
        ptr = ptr->next;
    } while (ptr != list->next);

    return NULL;
}